package com.csd.serviceImpl;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import com.csd.dao.EvaluateItemDAO;
import com.csd.dao.ProjectDAO;
import com.csd.dao.TeacherDAO;
import com.csd.exception.*;
import com.csd.helper.ProjectState;
import com.csd.pojo.EvaluateItem;
import com.csd.pojo.Project;
import com.csd.pojo.Teacher;
import com.csd.service.IEvaluateItemService;
import com.csd.vo.EvaluateItemVO;
import com.csd.vo.UserVO;

public class EvaluateItemService implements IEvaluateItemService {

	private EvaluateItemDAO evaluateItemDAO;

	private ProjectDAO projectDAO;
	private TeacherDAO teacherDAO;

	public TeacherDAO getTeacherDAO() {
		return teacherDAO;
	}

	public void setTeacherDAO(TeacherDAO teacherDAO) {
		this.teacherDAO = teacherDAO;
	}

	public ProjectDAO getProjectDAO() {
		return projectDAO;
	}

	public void setProjectDAO(ProjectDAO projectDAO) {
		this.projectDAO = projectDAO;
	}

	/**
	 * 删除评审项
	 * @param id
	 *        评审ID
	 * @return true为修改成功,false 为修改失败
	 */
   
	public boolean deleteEvaluateItem(Integer id) {
		EvaluateItem evaluateItem = null;
		try {
			evaluateItem = evaluateItemDAO.findById(id);
			evaluateItemDAO.delete(evaluateItem);
		} catch (RuntimeException re) {
			throw new DeleteException(re, "删除评估项异常");
		}
		return true;
	}

	public EvaluateItemDAO getEvaluateItemDAO() {
		return evaluateItemDAO;
	}

	public void setEvaluateItemDAO(EvaluateItemDAO evaluateItemDAO) 
	{
		this.evaluateItemDAO = evaluateItemDAO;
	}
	
	/**
	 * 获得评审项
	 * @param id
	 *        评审ID
	 * @return evaluateItem评审实例
	 */
	public EvaluateItem getEvaluateItemByID(Integer id) {
		EvaluateItem evaluateItem = null;
		try {
			evaluateItem = evaluateItemDAO.findById(id);
		} catch (RuntimeException re) {
			throw new GetException(re, "查询评估项异常");
		}
		return evaluateItem;
	}

	/**
	 * 保存评审项
	 * @param evaluateItem
	 *        评审实例
	 * @return true为保存成功,false 为保存失败
	 */
	public boolean saveEvaluateItem(EvaluateItem evaluateItem) {
		try 
		{
			evaluateItemDAO.save(evaluateItem);
		} catch (RuntimeException re) 
		{
			throw new SaveException(re, "添加评估项目异常");
		}
		return true;
	}
    
	/**
	 * 更新评审项
	 * @param evaluateItem
	 *        评审实例
	 * @return true为更新成功,false 为更新失败
	 */
	public boolean updateEvaluateItem(EvaluateItem evaluateItem) {
		try {
			evaluateItemDAO.update(evaluateItem);
		} catch (RuntimeException re) {
			throw new SaveException(re, "更新评估项异常");
		}
		return true;
	}

	/**
	 * 通过项目ID获得评审项
	 * @param id
	 *        项目ID
	 * @return evaluateItems 项目的所有评审项
	 */
	public List<EvaluateItem> listEvaluateItemByProjectID(Integer id) {
		List<EvaluateItem> evaluateItems = null;
		try {
			evaluateItems = evaluateItemDAO.listEvaluateItemByProjectID(id);
		} catch (RuntimeException re) {
		throw new GetException(re,"列出工程评估项异常");
		}
		return evaluateItems;
	}

	/**
	 * 更新评审项
	 * @param evaluateItemID,comment,evaluation,score
	 *        评审项ID,评论,评价,分数
	 * @return true为更新成功,false 为更新失败
	 */
	public boolean updateEvaluateItem(Integer evaluateItemID, String comment,
			String evaluation, int score) {

		EvaluateItem evaluateItem = null;
		evaluateItem = evaluateItemDAO.findById(evaluateItemID);
		evaluateItem.setComment(comment);
		evaluateItem.setEvaluation(evaluation);
		evaluateItem.setGrade(score);
		try {
			evaluateItemDAO.update(evaluateItem);

		} catch (RuntimeException re) {
					throw new GetException(re, "添加评估项目评论和分数异常");
				}


		return true;
	}


	/**
	 * 更新评审项
	 * @param id,result
	 *        评审项ID,结题申请结果
	 * @return true为更新成功,false 为更新失败
	 */
	public boolean updateEvaluateItem(Integer id, String result) {

		EvaluateItem evaluateItem = null;
		evaluateItem = evaluateItemDAO.findById(id);
		Project project = evaluateItem.getProject();

		if (result.equals("pass")) {
			project.setState(ProjectState.telophasePass);
		} else if (result.equals("reject")) {
			project.setState(ProjectState.telophasePass);
		} else {
			System.out.println("老师审核结题出错");
		}
		try {
			projectDAO.update(project);
			evaluateItemDAO.updateEvaluateItem(evaluateItem);
		} catch (RuntimeException re) {
			throw new UpdateException(re, "更新评估项目结果异常");
		}
		return true;
	}


	/**
	 * 通过老师ID和项目状态获得老师需要评审的项目
	 * @param teacherID
	 *        老师ID
	 * @return evaluateItem为列出老师的所有评审项目
	 */
	public List<EvaluateItem> listEvaluateItemByTeacherID(Integer teacherID) {
		List<EvaluateItem> evaluateItem = null;
		try {
			evaluateItem = evaluateItemDAO.listEvaluateItemByTeacherID(teacherID);
		} catch (RuntimeException re) {
			throw new GetException(re, "列出老师评估项异常");
		}

		return evaluateItem;
	}

	/**
	 * 查询出该项目的老师评审成绩
	 * 
	 * @param projectID
	 *            项目id
	 * @param stage
	 *            评审阶段
	 * @return 老师评审vo对象列表
	 */
	public List<EvaluateItemVO> getAllScoreOfProject(Integer projectID,String stage) {
		List<EvaluateItemVO> evaluateVOList = new ArrayList<EvaluateItemVO>();
		
		try {
			
			List<EvaluateItem> temp = evaluateItemDAO.getEvaluateItemOfProject(projectID,stage);
			for (Iterator iterator = temp.iterator(); iterator.hasNext();) {
				EvaluateItem e = (EvaluateItem) iterator.next();
				evaluateVOList.add(new EvaluateItemVO(e.getProject().getId(), e
						.getTeacher().getId(), e.getId(), e.getTeacher()
						.getName(), e.getGrade(), e.getComment(), e
						.getEvaluation(), e.getStage()));
			}
		} catch (RuntimeException re) {
			throw new GetException(re, "查询工程所有的评估项异常");
		}

		return evaluateVOList;
	}

	/**
	 * 管理员修改老师的评审成绩
	 * 
	 * @param evaluateItemID
	 *            评审id
	 * @param grade
	 *            分数
	 * @return true为更新成功,false 为更新失败
	 */
	public boolean updateEvaluationOfTeacher(Integer evaluateItemID,
			Integer grade) {
		boolean bl = false;
		EvaluateItem evaluateItem = null;
		try {
			evaluateItem = evaluateItemDAO.findById(evaluateItemID);
			if (evaluateItem != null) {
				evaluateItem.setGrade(grade);
				evaluateItemDAO.update(evaluateItem);
				bl = true;
			}
		} catch (RuntimeException re) {
			throw new GetException(re, "修改老师的评估异常");
		}

		return bl;
	}
	
	
	/**
	 * 查看该项目的评审項
	 * @param projectID,stage
	 *        项目ID,阶段
	 * @return uList 为项目的评审項
	 */
	public List<EvaluateItemVO> getEvaluationTeacher(Integer projectID, String stage)
	{
		List<EvaluateItemVO> uList = new ArrayList<EvaluateItemVO>();
		List<EvaluateItem> tempList = null;
		try {
			tempList = evaluateItemDAO.getEvaluateItemOfProject(projectID, stage);
			for (Iterator iterator = tempList.iterator(); iterator.hasNext();) {
				EvaluateItem e = (EvaluateItem) iterator.next();
				uList.add(new EvaluateItemVO(e.getProject().getId(), e
						.getTeacher().getId(), e.getId(), e.getTeacher()
						.getName(), -1, "", "", ""));
			}
		} catch (RuntimeException re) {
			throw new GetException(re, "列出工程老师的评估项异常");
		}

		return uList;
	}
   
	/**
	 * 获得老师的历史评估
	 * @param teacherID
	 *        老师ID
	 * @return evaluateItems 获得老师历史评审列表
	 */
	public List<EvaluateItem> listTeacherEHistory(Integer teacherID) {
		Teacher teacher = teacherDAO.findById(teacherID);
		List<EvaluateItem> evaluateItems = null;
		try {
			evaluateItems = evaluateItemDAO.listTeacherHistory(teacher);
		} catch (RuntimeException re) {
			throw new GetException(re, "查询老师的历史评估异常");
		}

		return evaluateItems;
	}
	
	public Integer getEvaluateItemID(Integer projectID, Integer teacherID)
	{
		List<EvaluateItem> id;
		id = evaluateItemDAO.getEvaluateItemID(projectID, teacherID);
		
		return id.get(0).getId();
	}

}
